package com.nengchuan.eic.nceconomy.util;

import com.nengchuan.eic.nceconomy.entity.po.OriginIndexData;
import com.nengchuan.eic.nceconomy.entity.po.TemplateDic;
import com.nengchuan.util.NullCheckUtils;

import java.util.List;

public class ExcelSerialNumUtils {

    //大写序号常量池
    private static String[] upperSequencePool={"一","二","三","四","五","六","七","八","九","十"};

    //小写括号序号常量池
    private static String[] downSequencePool={"(1)","(2)","(3)","(4)","(5)","(6)","(7)","(8)","(9)"};

    //序号分割点
    private static String point =".";

    //括号
    private static String bracket="(";

    //数字正则表达式
    private static String numberReg="^[0-9]*$";

    /**
     * 建筑单位工程汇总表（表三） 特殊处理为空特殊处理
     * @return
     */
    public static Long getParentSequenceTable3(List<OriginIndexData> history, OriginIndexData currNode){
        //如果序号为大写数字或为空,则它们本身为顶级节点
        String seq=currNode.getValue();
        history.add(currNode);
        if(NullCheckUtils.isNull(seq)){
            for (int i = history.size() - 2; i >= 0; i--) {
                String tempSeq=history.get(i).getValue();
                if(NullCheckUtils.isNotNull(tempSeq)){
                    return history.get(i).getId();
                }
            }
        }

        return null;
    }
    /**
     * 建筑单位工程汇总表（表三） 特殊处理为空特殊处理
     * @return
     */
    public static Long getParentSequenceTable3(List<OriginIndexData> history, OriginIndexData currNode,String name){
        //如果序号为大写数字或为空,则它们本身为顶级节点
        String seq=currNode.getValue();
        history.add(currNode);
        if(NullCheckUtils.isNull(seq)){
            for (int i = history.size() - 2; i >= 0; i--) {
                String tempSeq=history.get(i).getValue();
                if(NullCheckUtils.isNotNull(tempSeq)){
                    return history.get(i).getId();
                }
            }
        }

        return null;
    }

    /**
     * 建筑单位工程汇总表（表三） 特殊处理为空特殊处理
     * @return
     */
    public static Long getParentSequenceTable3(List<TemplateDic> history, TemplateDic currNode){
        //如果序号为大写数字或为空,则它们本身为顶级节点
        String seq=currNode.getValue();
//        if(!ExcelSerialNumUtils.isDownSeq(seq)){
//            history.add(currNode);
//        }

        if(NullCheckUtils.isNull(seq)||ExcelSerialNumUtils.isDownSeq(seq)){
            for (int i = history.size() - 2; i >= 0; i--) {
                String tempSeq=history.get(i).getValue();
                if(NullCheckUtils.isNotNull(tempSeq)){
                    return history.get(i).getId();
                }
            }
        }

        return null;
    }

    public static Long getParentSequence(List<TemplateDic> history, TemplateDic currNode){

        //如果序号为大写数字或为空,则它们本身为顶级节点
        String seq=currNode.getValue();
        history.add(currNode);
        if(NullCheckUtils.isNull(seq)){
            return null;
        }

        int count=countPoint(seq);
        if(count>0){
            for (int i = history.size() - 2; i >= 0; i--) {
                String tempSeq=history.get(i).getValue();
                if(NullCheckUtils.isNotNull(tempSeq)&&(countPoint(tempSeq)<count||
                        isNumber(tempSeq)||
                        hasBracket(tempSeq)||
                        isUpperSeq(tempSeq))){
                    return history.get(i).getId();
                }
            }
        }else if(isNumber(seq)){
            for (int i = history.size() - 2; i >= 0; i--) {
                String tempSeq=history.get(i).getValue();
                if(NullCheckUtils.isNotNull(tempSeq)&&(hasBracket(tempSeq)||
                        isUpperSeq(tempSeq))){
                    return history.get(i).getId();
                }
            }
        }else if(hasBracket(seq)){
            for (int i = history.size() - 2; i >= 0; i--) {
                String tempSeq=history.get(i).getValue();
                if(NullCheckUtils.isNotNull(tempSeq)&&isUpperSeq(tempSeq)){
                    return history.get(i).getId();
                }
            }
        }

        return null;
    }

    public static Long getParentSequence(List<TemplateDic> history, TemplateDic currNode,String sheetName){

        //如果序号为大写数字或为空,则它们本身为顶级节点
        String seq=currNode.getValue();
        history.add(currNode);
        if(NullCheckUtils.isNull(seq)){
            return null;
        }

        int count=countPoint(seq);
        if(count>0){
            for (int i = history.size() - 2; i >= 0; i--) {
                String tempSeq=history.get(i).getValue();
                if(NullCheckUtils.isNotNull(tempSeq)&&(countPoint(tempSeq)<count||
                        isNumber(tempSeq)||
                        hasBracket(tempSeq)||
                        isUpperSeq(tempSeq))){
                    return history.get(i).getId();
                }
            }
        }else if(isNumber(seq)){
            for (int i = history.size() - 2; i >= 0; i--) {
                String tempSeq=history.get(i).getValue();
                if(NullCheckUtils.isNotNull(tempSeq)&&(hasBracket(tempSeq)||
                        isUpperSeq(tempSeq))){
                    return history.get(i).getId();
                }
            }
        }else if(hasBracket(seq)){
            for (int i = history.size() - 2; i >= 0; i--) {
                String tempSeq=history.get(i).getValue();
                if(NullCheckUtils.isNotNull(tempSeq)&&isUpperSeq(tempSeq)){
                    return history.get(i).getId();
                }
            }
        }else if("主要设备材料汇总表".equals(sheetName)&&isUpperSeq(seq)){
            for (int i = history.size() - 2; i >= 0; i--) {
                String tempSeq=history.get(i).getValue();
                if(NullCheckUtils.isNull(tempSeq)){
                    return history.get(i).getId();
                }
            }
        }

        return null;
    }

    public static Long getParentSequence(List<OriginIndexData> history, OriginIndexData currNode,String sheetName){

        //如果序号为大写数字或为空,则它们本身为顶级节点
        String seq=currNode.getValue();
        history.add(currNode);
        if(NullCheckUtils.isNull(seq)){
            return null;
        }

        int count=countPoint(seq);
        if(count>0){
            for (int i = history.size() - 2; i >= 0; i--) {
                String tempSeq=history.get(i).getValue();
                if(NullCheckUtils.isNotNull(tempSeq)&&(countPoint(tempSeq)<count||
                        isNumber(tempSeq)||
                        hasBracket(tempSeq)||
                        isUpperSeq(tempSeq))){
                    return history.get(i).getId();
                }
            }
        }else if(isNumber(seq)){
            for (int i = history.size() - 2; i >= 0; i--) {
                String tempSeq=history.get(i).getValue();
                if(NullCheckUtils.isNotNull(tempSeq)&&(hasBracket(tempSeq)||
                        isUpperSeq(tempSeq))){
                    return history.get(i).getId();
                }
            }
        }else if(hasBracket(seq)){
            for (int i = history.size() - 2; i >= 0; i--) {
                String tempSeq=history.get(i).getValue();
                if(NullCheckUtils.isNotNull(tempSeq)&&isUpperSeq(tempSeq)){
                    return history.get(i).getId();
                }
            }
        }else if("主要设备材料汇总表".equals(sheetName)&&isUpperSeq(seq)){
            for (int i = history.size() - 2; i >= 0; i--) {
                String tempSeq=history.get(i).getValue();
                if(NullCheckUtils.isNull(tempSeq)){
                    return history.get(i).getId();
                }
            }
        }

        return null;
    }
    public static Long getParentSequence(List<OriginIndexData> history, OriginIndexData currNode){

        //如果序号为大写数字或为空,则它们本身为顶级节点
        String seq=currNode.getValue();
        history.add(currNode);
        if(NullCheckUtils.isNull(seq)){
            return null;
        }

        int count=countPoint(seq);
        if(count>0){
            for (int i = history.size() - 2; i >= 0; i--) {
                String tempSeq=history.get(i).getValue();
                if(NullCheckUtils.isNotNull(tempSeq)&&(countPoint(tempSeq)<count||
                        isNumber(tempSeq)||
                        hasBracket(tempSeq)||
                        isUpperSeq(tempSeq))){
                    return history.get(i).getId();
                }
            }
        }else if(isNumber(seq)){
            for (int i = history.size() - 2; i >= 0; i--) {
                String tempSeq=history.get(i).getValue();
                if(NullCheckUtils.isNotNull(tempSeq)&&(hasBracket(tempSeq)||
                        isUpperSeq(tempSeq))){
                    return history.get(i).getId();
                }
            }
        }else if(hasBracket(seq)){
            for (int i = history.size() - 2; i >= 0; i--) {
                String tempSeq=history.get(i).getValue();
                if(NullCheckUtils.isNotNull(tempSeq)&&isUpperSeq(tempSeq)){
                    return history.get(i).getId();
                }
            }
        }

        return null;
    }

    /**
     * 将两个新老序号对比父序号
     * 序号的优先顺序依次为 大写数字>带括号的数字>阿拉巴数字>含点的数字(点的多少确定顺序)
     *
     * 例:
     * 一 > (一) > 1 > 1.1 >1.1.1
     *
     * @param oldSeq
     * @param newSeq
     * @return
     */
    public static String getParentSequence(String oldSeq,String newSeq){
        //如果新序号不为以上定义,则直接返回新序号
        boolean isUpper=isUpperSeq(newSeq);
        boolean hasBracket=hasBracket(newSeq);
        boolean isNumber=isNumber(newSeq);
        int countPoint=countPoint(newSeq);
        if(!isUpper&&!hasBracket&&!isNumber&&countPoint<1){
            return newSeq;
        }

        //如果新序号为大写,则返回新序号
        if(isUpper){
            return newSeq;
        }

        //如果老序号为大写数字,则返回老序号
        if(isUpperSeq(oldSeq)){
            return oldSeq;
        }

        //如果新序号有括号,则返回新序号
        if(hasBracket){
            return newSeq;
        }

        //如果老序号有括号,则返回老序号
        if(hasBracket(oldSeq)){
            return oldSeq;
        }

        //如果新序号为数字,则返回新序号
        if(isNumber){
            return newSeq;
        }

        //如果老序号为数字,则返回新序号
        if(isNumber(oldSeq)){
            return oldSeq;
        }

        //如果新序号的点比老序号多,则返回老序号
        if(countPoint>countPoint(oldSeq)){
            return oldSeq;
        }

        return newSeq;
    }


    /**
     * 计算字符串中含.的个数
     * @param req
     * @return
     */
    private static int countPoint(String req){
        int fromIndex = 0;
        int count = 0;
        while(true){
            int index = req.indexOf(point, fromIndex);
            if(-1 != index){
                fromIndex = index + 1;
                count++;
            }else{
                break;
            }
        }
        return count;
    }

    /**
     * 是否为数字
     * @param req
     * @return
     */
    public static boolean isNumber(String req){
        return req.matches(numberReg);
    }

    /**
     * 序号是否有括号
     * @param req
     * @return
     */
    private static boolean hasBracket(String req){
        return req.contains(bracket);
    }

    /**
     *是否是大写序号
     * @param seq
     * @return
     */
    public static boolean isUpperSeq(String seq){
        for (int i = 0; i <upperSequencePool.length ; i++) {
            String temp=upperSequencePool[i];
            if(temp.equals(seq)){
                return true;
            }
        }
        return false;
    }
    /**
     *是否是小写
     * @param seq
     * @return
     */
    public static boolean isDownSeq(String seq){
        for (int i = 0; i <downSequencePool.length ; i++) {
            String temp=downSequencePool[i];
            if(temp.equals(seq)){
                return true;
            }
        }
        return false;
    }
}
